home *** CD-ROM | disk | FTP | other *** search
/ Aminet 7 / Aminet 7 - August 1995.iso / Aminet / misc / sci / RARS_Amiga_3.lha / RARS / misc.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-27  |  5.4 KB  |  172 lines
  1. // MISC.CPP - miscellaneous support functions - M. Timin, May, 1995
  2. // ver. 0.6b 5/8/95 b for beta
  3.  
  4. #include <string.h>
  5. #include "car.h"
  6. #include "os.h"
  7. #include "track.h"
  8.  
  9. // call repeatedly to change direction by 180 degrees:
  10. void reverse(double v, double* alpha_ptr, double* vc_ptr)
  11. {
  12.    if(v > 10.0)         // This is algorithm to reverse velocity vector:
  13.        *vc_ptr = 0.0;      // if not going very slow, brake hard
  14.     else
  15.        *vc_ptr = -15.0;    // when going slow enough, put 'er in reverse!
  16.     *alpha_ptr = 0.0;      // don't turn.
  17. }
  18.  
  19. /* This routine analyses the parameters to determine if the car is in an
  20.    abnormal situation.  If so, it returns non-zero & sets the result
  21.    vector so as to free the car.  If all is normal it returns zero.
  22.    This is a service for the robot drivers; it is only called by them. */
  23. int stuck(int backward, double v, double vn, double to_lft,
  24.                              double to_rgt, double* alpha_ptr, double* vc_ptr)
  25. {
  26.    if(to_lft < 0.0)        // If over the left wall, 
  27.       if(vn > .5 * v)  {  // test for more than 30 degrees off course
  28.          reverse(v, alpha_ptr, vc_ptr);
  29.          return 1;
  30.       }
  31.       else if(vn > -.5 * v && backward) {  // or going well backward
  32.          reverse(v, alpha_ptr, vc_ptr);
  33.          return 1;
  34.       }
  35.       else if(vn < -.5 * v) {    // heading away from wall,
  36.          *alpha_ptr = .03;       // turn to left
  37.          *vc_ptr = (.66667 * v + 10.0);  // accelerate toward 30 fps
  38.          return 1;
  39.       }
  40.       else {
  41.          *alpha_ptr = -.03;       // turn to right
  42.          *vc_ptr = (.66667 * v + 10.0);  // accelerate toward 30 fps
  43.          return 1;
  44.       }
  45.    else if(to_rgt < 0.0)  // if over the right wall:
  46.       if(vn < -.5 * v)  {  // test for more than 30 degrees off course
  47.          reverse(v, alpha_ptr, vc_ptr);
  48.          return 1;
  49.       }
  50.       else if(vn < .5 * v && backward) {  // or going well backward
  51.          reverse(v, alpha_ptr, vc_ptr);
  52.          return 1;
  53.       }
  54.       else if(vn > .5 * v) {    // heading away from wall,
  55.          *alpha_ptr = -.03;       // turn to right
  56.          *vc_ptr = .66667 * v + 10.0;  // accelerate toward 30 fps
  57.          return 1;
  58.       }
  59.       else {
  60.          *alpha_ptr = .03;       // turn to left
  61.          *vc_ptr = .66667 * v + 10.0;  // accelerate toward 30 fps
  62.          return 1;
  63.       }
  64.    else if(backward)
  65.      if(vn > .866 * v)  { // you are going more-or-less sideways left
  66.         *alpha_ptr = -.03;
  67.         *vc_ptr = .66667 * v + 10;
  68.          return 1;
  69.      }
  70.      else if(vn < -.866 * v) {  // you are going more-or-less sideways rt.
  71.         *alpha_ptr = .03;
  72.         *vc_ptr = .66667 * v + 10;
  73.          return 1;
  74.      }
  75.      else {
  76.       reverse(v, alpha_ptr, vc_ptr);
  77.       return 1;
  78.      }
  79.    else if(v < 15) {  // nothing wrong except you are going very slow:
  80.       if(to_rgt > to_lft)     // you are on left side of track
  81.          if(vn < -.7 * v)     // and you are not heading very much to right
  82.             *alpha_ptr = -.03;
  83.          else
  84.             *alpha_ptr = .03;
  85.       else                   // you are on the right side,
  86.          if(vn > .7 * v)     // and you are not heading very much to left
  87.             *alpha_ptr = .03;
  88.          else
  89.             *alpha_ptr = -.03;
  90.      *vc_ptr = .66667 * v + 10;    // acellerate moderately
  91.       return 1;
  92.    }
  93.    return 0;   // We get here only if all is normal.
  94. }
  95.  
  96. // create a default situation vector to pass to control() during initializaton
  97. situation fill_situation(rel_state* rel_state_vec_ptr)
  98. {
  99.    situation result;
  100.  
  101.    result.cur_rad = 0.0;
  102.    result.cur_len = 1.0;
  103.    result.to_lft =  1.0;    
  104.    result.to_rgt =  1.0;  
  105.    result.to_end =  1.0;    
  106.    result.v = 20.0;    
  107.    result.vn = 0.0;        
  108.    result.nex_len = 1.0;   
  109.    result.nex_rad = 1.0;   
  110.    result.after_rad = 0.0;
  111.    result.power_req = 1.0; 
  112.    result.dead_ahead = 0;   
  113.    result.backward = 0;     
  114.    result.nearby = rel_state_vec_ptr;
  115.    for(int k=0; k<3; k++)
  116.       result.nearby[k].who = 999;
  117.  
  118.    return result;
  119. }
  120.  
  121. // limits the rate of change and maximum value of the angle of attack:
  122. double alpha_limit(double was,       // This is what alpha was
  123.                    double request)   // The robot wants this alpha
  124. {
  125.    const double MAX_RATE = 3.2;  // maximum radians per second possible
  126.    const double MAX_ALPHA= 1.0;   // maximum radians possible
  127.  
  128.    double alpha;                 // the result to return
  129.  
  130.    if(request - was > MAX_RATE * delta_time)   // want more positive alpha
  131.       alpha = was + MAX_RATE * delta_time;
  132.    else if(was - request > MAX_RATE * delta_time)  // want more negative alpha
  133.       alpha = was - MAX_RATE * delta_time;
  134.    else
  135.       alpha = request;
  136.  
  137.    if(alpha > MAX_ALPHA)
  138.       alpha = MAX_ALPHA;
  139.    else if(alpha < -MAX_ALPHA)
  140.       alpha = -MAX_ALPHA;
  141.  
  142.    return alpha;
  143. }
  144.  
  145. // This routine is so that the KB is polled much less frequently when
  146. // we are trying to speed up the simulation, as indicated by the no_display
  147. // and real_speed global variables.
  148. int do_kb(void)      // Returns non_zero when kb should be polled.
  149. {
  150.    static int kb_count = 0;
  151.  
  152.    ++kb_count;
  153.    if(no_display) 
  154.       if(kb_count >= 50) {
  155.          kb_count = 0;
  156.          return 1;
  157.       }
  158.       else
  159.          return 0;
  160.    else if(!real_speed)
  161.       if(kb_count >= 10) {
  162.          kb_count = 0;
  163.          return 1;
  164.       }
  165.       else
  166.          return 0;
  167.    // This is when there is a display and the speed is realistic
  168.    kb_count = 0;
  169.    return 1;
  170. }
  171.  
  172.